数据持久化

Typeorm 官方文档 https://typeorm.io/

TypeORM 是啥

TypeORM 是一个 ORM 框架。ORM(Object–relational mapping) 是指对象关系映射，是一种将某种编程语言中的对象转换为其他不兼容系统中的数据。ORM 最常见使用便是对象与数据库表之间的转换。

Mongoose 官方文档 https://mongoosejs.com/

Mongoose 是啥

Mongoose 是 MongoDB 的一个对象模型工具，是基于 node-mongoldb-native 开发的 MongoDB nodes 驱动，可以在异步的环境下执行。同时它也是针对 MongoDB 操作的一个对象模型库，封装了 MongoDB 对文档的的一些增删改查等常用方法，让 Node JS 操作 Mongodb 数据库变得更加灵活简单。

封装

typeorm

pnpm i typeorm
pnpm i mongodb

import { DataSource, DataSourceOptions } from 'typeorm';
const path = require('path');
import { ConfigService } from '@nestjs/config';

// 设置数据库类型
const databaseType: DataSourceOptions['type'] = 'mongodb';
// 数据库注入
export const DatabaseProviders = [
  {
      provide: 'MONGODB_DATA_SOURCE',
      inject: [ConfigService],
      useFactory: async (configService: ConfigService) => {
          const config = {
              type: databaseType,
              url: configService.get<string>('database.url'),
              username: configService.get<string>('database.user'),
              password: configService.get<string>('database.pass'),
              database: configService.get<string>('database.name'),
              entities: [path.join(__dirname, `../../**/*.mongo.entity{.ts,.js}`)],
              logging: configService.get<boolean>('database.logging'),
              synchronize: configService.get<boolean>('database.synchronize'),
          }

          const ds = new DataSource(config)
          await ds.initialize()
          return ds
      }
  }
];

src/shared/shared.module.ts

import { Module } from '@nestjs/common';
import { DatabaseProviders } from './database/database.providers';

@Module({
  exports: [
    ...DatabaseProviders,
  ],
  providers: [
    ...DatabaseProviders,
  ],
})
export class SharedModule { }

src/user/user.providers.ts

import { User } from './entities/user.mongo.entity';

export const UserProviders = [
    {
        provide: 'USER_REPOSITORY',
        useFactory: async (AppDataSource) => await AppDataSource.getRepository(User),
        inject: ['MONGODB_DATA_SOURCE'],
    }
];

src/user/user.module.ts

import { Module } from '@nestjs/common';
import { SharedModule } from '@/shared/shared.module';
import { ConfigService } from '@nestjs/config';

@Module({
  imports: [
    SharedModule,
  ],
  
  providers: [...UserProviders,]

})
export class UserModule { }

src/entites/user.mongo.entity.ts

import { Column, Entity, ObjectID, ObjectIdColumn } from "typeorm";

@Entity()
export class User {

    @ObjectIdColumn()
    _id: ObjectID;

    @Column('text')
    name: string

    @Column({ length: 200 })
    email: string

}

src/services/user.service.ts

import { User } from '../entities/user.mongo.entity';

@Injectable()
export class UserService {
  constructor(
    @Inject('USER_REPOSITORY')
    private userRepository: MongoRepository<User>,
  ) { }


  async create(user) {
    return this.userRepository.save(user)
  }


  async findAll({ pageSize, page }: PaginationParams2Dto): Promise<{ data: User[], count: number }> {

    const [data, count] = await this.userRepository.findAndCount({
      order: { createdAt: 'DESC' },
      skip: (page - 1) * pageSize,
      take: (pageSize * 1),
      cache: true,
    })

    return {
      data, count
    }
  }

  async findOne(id: string) {
    return await this.userRepository.findOneBy(id)
  }

  async update(id: string, user: CreateUserDto) {


    return await this.userRepository.update(id, user)
  }

  async remove(id: string): Promise<any> {
    return await this.userRepository.delete(id)
  }


}

mongoose

user.schema.ts

import { Schema } from 'mongoose';
import { UserInterface } from '../../interfaces/user.interface';

export const UserSchema = new Schema<UserInterface>(
  {
    phone: {
      type: String,
      required: true,
    },
    password: {
      type: String,
      required: true,
    },
    email: {
      type: String,
    },
    username: {
      type: String,
    },
    create_datetime: {
      type: Date,
      default: Date.now,
    },
    update_datetime: {
      type: Date,
      default: Date.now,
    },
  },
  {
    versionKey: false,
    timestamps: {
      createdAt: 'create_datetime',
      updatedAt: 'update_datetime',
    },
  },
);

user.interface.ts

export interface UserInterface {
  phone: string;
  password: string;
  email: string;
  username: string;
  create_datetime: Date;
  update_datetime: Date;
}

user.module.ts

import { Module } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';

import { UserService } from './user.service';
import { UserController } from './user.controller';
import { SharedModule } from '../shared/shared.module';

import { UserSchema } from '../schamas/NoSQL/user.schema';

@Module({
  imports: [
    SharedModule,
    MongooseModule.forFeature([
      {
        name: 'User',
        schema: UserSchema,
        collection: 'user',
      },
    ]),
  ],
  controllers: [UserController],
  providers: [UserService],
})
export class UserModule {}

app.module.ts

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { UserModule } from './user/user.module';
import { SharedModule } from './shared/shared.module';
import { MongooseModule } from '@nestjs/mongoose';

@Module({
  imports: [
    MongooseModule.forRoot(process.env.DB_URL, {
      useNewUrlParser: true,
    }),
    UserModule,
    SharedModule,
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

sequelize

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { SequelizeModule } from '@nestjs/sequelize';
import { UserSchema } from './schamas/SQL/user.schema';

@Module({
  imports: [
    SequelizeModule.forRoot({
      dialect: 'postgres',
      host: 'localhost',
      port: 5432,
      username: 'root',
      password: 'root',
      database: 'postgres',
      autoLoadModels: true,
      synchronize: true,
      models: [UserSchema],
    }),
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

user.schema.ts

import { Table, Column, Model } from 'sequelize-typescript';
import { UserInterface } from '../../interfaces/user.interface';

@Table
export class UserSchema extends Model<UserInterface> {
  @Column
  username: string;

  @Column
  phone: string;

  @Column
  password: string;

  @Column
  email: string;
}